import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import '../../../common/utils/index.dart';

class NetworkDiagnosticsController extends GetxController {
  // 1. 静态常量（类级别）
  static const String tag = 'NetworkDiagnosticsController';
  static const int maxRetryCount = 3;
  static const Duration defaultTimeout = Duration(seconds: 30);
  
  // 2. 实例常量
  final String pageTitle = '网络诊断';
  final Duration snackbarDuration = const Duration(seconds: 2);
  
  // 3. 响应式变量（Rx系列）
  // 基础类型 - 使用.obs写法（推荐95%场景）
  var isRunningDiagnostics = false.obs;        // 是否正在运行诊断
  var diagnosticReport = ''.obs;               // 诊断报告文本
  var retryCount = 0.obs;                     // 重试次数
  
  // 复杂对象 - 使用.obs写法
  var diagnosticResult = Rxn<NetworkDiagnosticResult>(); // 诊断结果（可空）
  
  // 集合类型 - 使用.obs写法
  var diagnosticHistory = <String>[].obs;      // 诊断历史记录
  
  // 4. 普通变量（非响应式）
  bool _isInitialized = false;
  String _lastError = '';
  
  // 公共访问器
  String get lastError => _lastError;
  
  // 5. 控制器和服务依赖
  // late final DioService _dioService;
  // late final StorageService _storageService;
  
  // 6. 构造函数
  NetworkDiagnosticsController() {
    // _dioService = Get.find<DioService>();
    // _storageService = Get.find<StorageService>();
    debugPrint('$tag: Constructor');
  }

  // 7. 私有初始化方法
  void _initData() {
    debugPrint('$tag: 初始化网络诊断数据');
    _isInitialized = true;
    retryCount.value = 0;
    diagnosticHistory.clear();
    diagnosticReport.value = '';
    diagnosticResult.value = null;
    update(["network_diagnostics"]);
    
    // 页面加载完成后自动开始网络诊断
    Future.delayed(const Duration(milliseconds: 500), () {
      if (_isInitialized) {
        debugPrint('$tag: 自动开始网络诊断');
        runFullDiagnostics();
      }
    });
  }

  // 8. 业务方法
  
  /// 运行完整网络诊断
  void runFullDiagnostics() async {
    if (isRunningDiagnostics.value || !_isInitialized) return;
    
    debugPrint('$tag: 开始网络诊断');
    isRunningDiagnostics.value = true;
    diagnosticResult.value = null;
    diagnosticReport.value = '';
    _lastError = '';
    update(["network_diagnostics"]); // 通知UI更新状态
    
    try {
      // 显示开始提示
      // _showSnackbar(
      //   title: '网络诊断',
      //   message: '正在检测网络连接状态，请稍候...',
      //   backgroundColor: Colors.blue.shade100,
      //   textColor: Colors.blue.shade800,
      //   icon: Icons.network_check,
      //   iconColor: Colors.blue.shade600,
      // );
      
      // 执行诊断
      final result = await NetworkDiagnostics.runFullDiagnostics();
      
      // 更新结果
      diagnosticResult.value = result;
      diagnosticReport.value = NetworkDiagnostics.generateDiagnosticReport(result);
      
      // 添加到历史记录
      final historyItem = '${DateTime.now()}: ${getStatusText(result.overallStatus)}';
      diagnosticHistory.add(historyItem);
      
      // 显示结果提示
      // _showDiagnosticResultSnackbar(result);
      
      debugPrint('$tag: 网络诊断完成 - 状态: ${result.overallStatus}');
      
    } catch (e) {
      _lastError = e.toString();
      debugPrint('$tag: 网络诊断异常: $e');
      
      // _showSnackbar(
      //   title: '诊断失败',
      //   message: '网络诊断过程中发生错误: ${e.toString()}',
      //   backgroundColor: Colors.red.shade100,
      //   textColor: Colors.red.shade800,
      //   icon: Icons.error,
      //   iconColor: Colors.red.shade600,
      //   duration: const Duration(seconds: 3),
      // );
      
    } finally {
      isRunningDiagnostics.value = false;
      update(["network_diagnostics"]); // 通知UI更新最终状态
    }
  }
  
  /// 快速网络检测
  void quickNetworkCheck() async {
    if (isRunningDiagnostics.value || !_isInitialized) return;
    
    debugPrint('$tag: 快速网络检测');
    
    try {
      // _showSnackbar(
      //   title: '快速检测',
      //   message: '正在检测网络连接...',
      //   backgroundColor: Colors.orange.shade100,
      //   textColor: Colors.orange.shade800,
      //   icon: Icons.speed,
      //   iconColor: Colors.orange.shade600,
      //   duration: const Duration(seconds: 1),
      // );
      
      final isConnected = await NetworkDiagnostics.quickNetworkCheck();
      
      if (isConnected) {
        // _showSnackbar(
        //   title: '网络正常',
        //   message: '基础网络连接正常',
        //   backgroundColor: Colors.green.shade100,
        //   textColor: Colors.green.shade800,
        //   icon: Icons.check_circle,
        //   iconColor: Colors.green.shade600,
        // );
        
        // 添加到历史记录
        diagnosticHistory.add('${DateTime.now()}: 快速检测 - 网络正常');
      } else {
        // _showSnackbar(
        //   title: '网络异常',
        //   message: '网络连接存在问题，建议运行完整诊断',
        //   backgroundColor: Colors.red.shade100,
        //   textColor: Colors.red.shade800,
        //   icon: Icons.error,
        //   iconColor: Colors.red.shade600,
        //   duration: const Duration(seconds: 3),
        // );
        
        // 添加到历史记录
        diagnosticHistory.add('${DateTime.now()}: 快速检测 - 网络异常');
      }
      
      update(["network_diagnostics"]); // 通知UI更新历史记录
      
    } catch (e) {
      _lastError = e.toString();
      debugPrint('$tag: 快速检测异常: $e');
      
      // _showSnackbar(
      //   title: '检测失败',
      //   message: '快速网络检测失败: ${e.toString()}',
      //   backgroundColor: Colors.red.shade100,
      //   textColor: Colors.red.shade800,
      //   icon: Icons.error,
      //   iconColor: Colors.red.shade600,
      //   duration: const Duration(seconds: 3),
      // );
      
      // 添加到历史记录
      diagnosticHistory.add('${DateTime.now()}: 快速检测 - 检测失败');
      update(["network_diagnostics"]);
    }
  }
  
  /// 清除诊断结果
  void clearDiagnosticResult() {
    if (!_isInitialized) return;
    
    debugPrint('$tag: 清除诊断结果');
    diagnosticResult.value = null;
    diagnosticReport.value = '';
    diagnosticHistory.clear();
    _lastError = '';
    
    // _showSnackbar(
    //   title: '已清除',
    //   message: '诊断结果已清除',
    //   backgroundColor: Colors.grey.shade100,
    //   textColor: Colors.grey.shade700,
    //   duration: const Duration(seconds: 1),
    // );
    
    update(["network_diagnostics"]); // 通知UI更新
  }
  
  /// 分享诊断报告
  void shareDiagnosticReport() {
    if (diagnosticReport.value.isEmpty) {
      // _showSnackbar(
      //   title: '无法分享',
      //   message: '没有可分享的诊断报告',
      //   backgroundColor: Colors.orange.shade100,
      //   textColor: Colors.orange.shade800,
      // );
      return;
    }
    
    debugPrint('$tag: 分享诊断报告');
    
    // 这里可以集成分享功能
    // await Share.share(diagnosticReport.value);
    
    // _showSnackbar(
    //   title: '诊断报告',
    //   message: '报告内容已复制到剪贴板',
    //   backgroundColor: Colors.blue.shade100,
    //   textColor: Colors.blue.shade800,
    //   icon: Icons.share,
    //   iconColor: Colors.blue.shade600,
    // );
  }
  
  /// 重试诊断
  void retryDiagnostics() {
    if (!_isInitialized || isRunningDiagnostics.value) return;
    
    debugPrint('$tag: 重试诊断 - 当前重试次数: ${retryCount.value}');
    
    if (retryCount.value >= maxRetryCount) {
      // _showSnackbar(
      //   title: '重试次数超限',
      //   message: '已达到最大重试次数($maxRetryCount次)',
      //   backgroundColor: Colors.red.shade100,
      //   textColor: Colors.red.shade800,
      //   icon: Icons.warning,
      //   iconColor: Colors.red.shade600,
      // );
      return;
    }
    
    retryCount.value++;
    runFullDiagnostics();
  }
  
  /// 重置重试计数
  void resetRetryCount() {
    debugPrint('$tag: 重置重试计数');
    retryCount.value = 0;
    update(["network_diagnostics"]);
  }

  // 私有辅助方法
  
  // 注释掉Snackbar相关方法，改为在UI中显示状态
  // /// 通用Snackbar显示方法
  // void _showSnackbar({
  //   required String title,
  //   required String message,
  //   required Color backgroundColor,
  //   required Color textColor,
  //   IconData? icon,
  //   Color? iconColor,
  //   Duration? duration,
  // }) {
  //   Get.snackbar(
  //     title,
  //     message,
  //     duration: duration ?? snackbarDuration,
  //     backgroundColor: backgroundColor,
  //     colorText: textColor,
  //     icon: icon != null ? Icon(icon, color: iconColor ?? textColor) : null,
  //   );
  // }
  
  // /// 显示诊断结果提示
  // void _showDiagnosticResultSnackbar(NetworkDiagnosticResult result) {
  //   // 结果已通过UI状态指示器显示，不再需要Snackbar
  // }
  
  /// 获取状态颜色
  Color getStatusColor(NetworkStatus status) {
    switch (status) {
      case NetworkStatus.good:
        return Colors.green.shade600;
      case NetworkStatus.warning:
        return Colors.orange.shade600;
      case NetworkStatus.error:
        return Colors.red.shade600;
    }
  }
  
  /// 获取状态图标
  IconData getStatusIcon(NetworkStatus status) {
    switch (status) {
      case NetworkStatus.good:
        return Icons.check_circle;
      case NetworkStatus.warning:
        return Icons.warning;
      case NetworkStatus.error:
        return Icons.error;
    }
  }
  
  /// 获取状态文本
  String getStatusText(NetworkStatus status) {
    switch (status) {
      case NetworkStatus.good:
        return '正常';
      case NetworkStatus.warning:
        return '警告';
      case NetworkStatus.error:
        return '错误';
    }
  }

  // 9. 生命周期方法
  
  @override
  void onInit() {
    super.onInit();
    debugPrint('$tag: onInit - 网络诊断控制器初始化');
  }

  @override
  void onReady() {
    super.onReady();
    debugPrint('$tag: onReady - 页面准备就绪，开始初始化数据');
    _initData();
  }
  
  @override
  void onClose() {
    debugPrint('$tag: onClose - 网络诊断控制器销毁');
    // 清理资源
    diagnosticHistory.clear();
    super.onClose();
  }
}
